# -*-codeing = utf-8 -*-
# @Time: 2025/7/1 19:21
# @Author : 邓佳丽
# @File : text01.py
# @Software : PyCharm
#列表拷贝
import copy
import time

'''name1=[['zhangsan','lisi','wangwu'],'zhaoliu']
name2=name1.copy()
name1[0][1]='hhhh'
name1[1]='yuuy'
print(name1)
print(name2)

print('~~~~~~~')

name1=[['zhangsan','lisi','wangwu'],'zhaoliu']
name2=copy.deepcopy(name1)
name1[0][1]='hhhh'
name1[1]='yuuy'
print(name1)
print(name2)

#推导式
L = [x**2 for x in range(1, 6)]
print(L)

L=['{}*{}'.format(x,j)for x in range(1,4) for j in range(1,4)]
print(L)

L=[x*j for x in range(1,4) for j in range(1,4,2)]
print(L)

L=[x*j for x in range(1,4,2) for j in range(1,4,2)]
print(L)

num=[]
for i in range(2,1001):
    L=[i%j for j in range(2,i)]
    if L.count(0):
        pass
    else:num.append(i)
print(num)

L = [x for x in range(2, 11) if all(x % y != 0 for y in range(2, x))]
print(L)
#all:所有元素为 True，则返回 True。
#只要有一个元素为 False，立即返回 False（短路计算，后续不再检查）。

#字符串格式化表达
print('%10d'%123)
print('%s and %*.*f' % ('abc',3,5,3.1415926))
'''

#元组(元素值不可变，运算都是在原有基础上加值)
'''t=(1,2,3,4)
print(t)
print(t[0])
t1=t+(5,6)
print(t1)
t2=t*2
print(t2)
print((1,2)>(3,4))
del t
'''
'''
L=(1,7,5,6,3)
sorted_L=sorted(L)
print(sorted_L)
print(L)
x=tuple(sorted_L)
print(x)

L=[1,4,66,2,3,8]
L.sort()
print(L)
SOR=sorted(L,reverse=True)
print(SOR)
print(L)

#sorted,临时 sort,永久.元组不支持永久排序,不支持改内容
L1=[1,5,2,'abc','fds']
L2=['34','445','8886','asdf']
t1=(1,5,2,'abc','fds')
t2=('34','445','8886','asdf')

L2.sort()
print(L2)
L2_sort=sorted(L2)
print(L2)
t2_sort=sorted(t2)
print(t2)
'''

#字典,dict
#通过下标索引处理列表（元组）
'''
d={'name':'djl','age':25,'addr':'beijing','job':'actor'}
print(d)
d=dict([('name','张三'),('age',30)])
d=dict(name='李四',age=25)
print(d)
d['addr']='杭州'
del(d['addr'])
d['name']='李五'
print(d.get('name'))
print(d['name'])
print(d)
'''
'''
d={'name':'djl','age':25,'addr':'beijing','job':'actor'}
print(len(d))
print(d.keys())
print(d.values())
print(d.items()) #键值对组成的元组，由若干个元组组成
'''

'''[{'name':'张三','age':20,'addr':'北京'},
 {},
 {},
 {}]'''
'''
print('个人名片管理系统，请输入要进行的操作：')
print('1：添加一个名片')
print('2:删除一个名片')
print('3:修改一个名片')
print('4.查询一个名片')
print('5.显示所有信息')
print('6.退出系统')
cards=[]
while True:
    num=int(input('请输入序号：'))
    if num==1:
        card={}
        name=input("输入名字：")
        age=int(input("输入年龄："))
        addr=input("输入地址：")
        card['name']=name
        card['age']=age
        card['addr']=addr
        cards.append(card)
        print(cards)
    elif num==2:
        delkey=input("删除的名片name：")
        flag=False
        for i in cards:   #i给的是列表中第一个字典的地址
            if i['name']==delkey:
                cards.remove(i)  #直接放i进去山删除整个字典
                flag=True
        if flag==False:
            print('没有找到')
        print(cards)
    elif num==3:
        flag=False
        altkey=input('修改的名片：')
        altname=input('修改的名字信息：')
        for i in cards:
            if i['name']==altkey:
                i['name']=altname
                flag=True
            if flag==False:
                print('没找到')
        print(cards)
    elif num==4:
        selkey=input('查询的信息：')
        for i in cards:
            if i['name']==selkey:
                print(i)
            else:print('没找到')
    elif num==5:
        print(cards)
    elif num==6:
        break
'''

#集合:无序set，去重,可变，元素只能是不可变的
'''s=set()
print(s)
s={1,2,4,5,6,6,6,6,}
print(s)
str='12345656abc'
s=set(str)
print(s)
str='123456abc'

L=[2,6,45,4,7,8]
t=(3,45,6,7,4,5)
d={'name':'郭德纲','age':20}

s={'abc',(2,4,5)}
print(s)
'''
#子集：A<B A.issubset(B),并集：A|B A.union(B)
#交集：A&B  差集：A-B  对称差：A^B A.symmetric_difference()：只在一方，另一方没有
'''
s={1,3,5,7,9,9}
s1={2,4,6,8,9,9}
print(s,s1)
s.add(10)
s.pop()
s.remove(3)
s.discard(3)
print(s)
print(s<s1)
s={1,2,3,4}
s1={1,2,3,4,5,6}
print(s<s1,s.issubset(s1))
print(s|s1,s.union(s1))
print(s&s1,s.intersection(s1))
s={1,2,3,4,7,8}
s1={1,2,3,4,5,6}
print(s-s1,s1-s)
print(s^s1,s.symmetric_difference(s1))
'''
#in not in :可搭配if使用判断是否在里面
'''
A={'宋江','吴用','燕青'}
print(A)
if '宋江' in A:
    print('宋江在里面')
 '''

#固定集合，不可变类型
'''s=frozenset()
s=frozenset([2,3,2,5,6,7])
print(s)'''

#集合的推导式
#{内容一样}

#函数
def 函数名(参数列表):
    pass
'''
def prit(x,y):
    print(x+y)
    print(max(x,y))
    print(min(x,y))

i,j=map(int,(input('输入：')).split())
prit(i,j)
'''
#1.n/2+1  2....  10.1

#猴子吃桃
'''
def count(day,n):
    while day:
        n=(n+1)*2
        day-=1
    print(n)

day=9
count(day,1)

#完全数问题 6=1+2+3
def wanquanshu(n):
    num=[]
    for i in range(1,n):
      if n%i==0:
          num.append(i)
    if sum(num) == n:
        print('YES')

n=int(input('输入一个数：'))
wanquanshu(n)

L=[1,2,3,4]
print(sum(L))
'''
#global:局部为全局 全局一起改
#序列传参
'''
def f1(a,b,c):
    print(a,b,c)
f1(*'qwe')
f1(*[1,2,3])

#字典关键字传参(关键字传参）
def f1(a,b,c):
    print(a,b,c)
a=(1,2,3)
d={'a':25,'b':765,'c':565}
f1(**d)

#组合传参
def f1(a,b,c):
    print(a,b,c)
f1(100,*[120,130])
f1(*'12',300)
f1(100,c=300,b=200)
f1(**{'c':300,'b':200},a=100)
#只可以先使用位置，在使用关键字

#形参
#缺省(默认)的形参（从右往左依次出现）
def info(name,age=1,addr='北京'):
    print(name,'今年',age,'住址',addr)

info('张三')
info('李四',20)
info('李四',21,'杭州')
'''
'''
def count(a,b,c=None):
    if c is None or c==0:
          return a+b
    else:
        return (a+b)%c
count(1,2)

#*星号元组形参
def f(*元组形参名):
    pass
#一般写成 f(*args)
def f(*args):
    print(args)
    print(max(args))
f(1,2,3,2,3,5,4,5)
f('aa','aaaa','ad')

#命名关键字形参
def f(*args,命名关键字形参):#*规范了后面必须使用关键字传参
    pass
def f(a,b,*args,d,e):
    print(args,d,e)
f(1,2,4,7,3,d=100,e=200)

#**双星号字典形参,实参必须是关键字形式，才能键值对
def f(**字典形参名):
    pass
def f(**kwargs):
    print(kwargs)
f(a=1)
'''
'''
def f(a,b,*args,c,**kwargs):
    print(a,b,c,args,kwargs)
f(1,2,3,4,5,c=1,z=9)

def f(*args,**kwargs):
    print(args,kwargs)
f(1,2,3,a=3,b=5)

#模拟range函数，写一个myrange()，返回列表
def myrange(start,stop=None,step=1):
    if stop is None:
        #stop=start
        #start=1
        #当传的参数是一个时，要将start赋给stop，在将start=1
        start,stop=1,start
    result=[]
    while (step > 0 and start < stop):
        result.append(start)
        start += step
    return result
print(myrange(5))
print(myrange(2, 7))
print(myrange(1, 10, 2))

def myrange(start,stop,step):
    result=[]
    while start<stop:
        result.append(start)
        start+=step
    return result
result=myrange(1,5,2)
print(result)

for i in range(-9,-1):
    print(i)
'''
'''
#函数变量：一个函数会绑在一个变量上，可以做返回值和参数
def f1(a):
    print(a)
f1(1)
print(f1)

def f1():
    print('h')
def f2():
    print('e')
def fn(f):
    print(f)
    f()

fn(f1)
fn(f2)
'''

#函数作为变量时，可以作为一个函数的返回值
#1+1
'''
def myadd(x,y):
    return x+y
def mymul(x,y):
    return x-y
def get_ops(s):
    if s=='+':
        return myadd
    elif s=='-':
        return mymul
def main():
    while True:
        s=input('请输入；')
        L=s.split()
        a,s,b=L
        a,b=int(a),int(b)
        f=get_ops(s)
        print(f(a,b))

main()
'''

#匿名函数
#lambda 形参:函数体
'''
cards=[{'name':'郭德纲','age':22},
       {'name':'于谦','age':21},
       {'name':'张三','age':20},
       {'name':'李四','age':19}]
#key表示sort比较时的依据。x收取列表中每一个元素，第二个x返回age的value值
cards.sort(key=lambda x:x['age'])
print(cards)

s='nihao my name is 郭德纲 \nand you\t?'
L=s.split()  #以空格，换行tab分割成列表
print(L)
s=' '.join(L)   #以空格拼接
print(s)
'''
'''
s='nihao my name is 郭德纲 \nand you\t?'
f=lambda x:' '.join(x.split())    #这一句是一个函数，有功能
print(f(s))
#lambda没有特殊函数，只作为一个标记，表示此处是匿名函数
 #冒号前面表示这个函数的形参，冒号后面表示函数体，而且不用写return
#作用:不用写名字，直接在定义这个函数的地方使用

#计算一百以内所有数值的平方组成的列表.
#map(函数,可迭代对象)  #把可迭代对象中所有值都作用到函数当中
print(list(map(lambda x:x**2,range(1,101))))
L=[lambda args:args**2,lambda args:args**3]
L[1](2) ----8   #第一个是位置，第二个是传参

#s.split():可以将字符串变成列表，list（）：可以把可迭代对象变为列表
'''

'''
#eval(字符串/对象形式，global=None，locals=None) 将字符串做为表达式执行，返回计算结果
x,y=1,2
a=eval('x+y')
print(a)
#exec():把一个字符串当做程序来执行,没有返回值
x,y=1,2
s="z=x+y;print(z);del z;print('删除成功');"
exec(s)
'''
'''
x = 1
y = 2
s='print(x+y)'
exec(s)

exec(s,{'x':10,'y':20})  #提供了全局，30

exec(s,{'x':10},{'x':100,'y':200})  #全局局部选局部

exec(s,{'x':10},{'y':200})

n=int(input('请输入:'))
print(sum(list(map(lambda x:x**x,range(1,n+1)))))
'''

#函数编程
'函数的可重入性'

 #map(),sorted(key),filter()
# map(lambda x,y,z:x+y+z,range(1,3),range(1,4))#选择最小的

'''
print(sum(map(lambda x,y:x**y,range(1,5),range(4,0,-1))))
#筛选可迭代对象中数据，经过函数为真保留为假舍弃
#filter(函数，可迭代对象)，找出100以内的奇数和偶数
l1=list(filter(lambda x:x%2==0,range(1,101)))
L2=list(filter(lambda x:x%2!=0,range(1,101)))
print(l1)
print(L2)
#找出一百一内所有的素数
def is_prime(x):
    for i in range(2,x):
        if x%i==0:
            return False
    return True
l1=list(filter(is_prime,range(1,101)))
print(l1)

L3=list(map(lambda x,y,z:x+y+z,range(1,3),range(1,4),range(2,5)))
print(L3)
'''
'''
#sorted()
L=[5,2,7,3,1,9,5,2,-2,-6]
#降序排列
print(sorted(L,reverse=True))
#升序排列
print(sorted(L))
#绝对值排序
L1=sorted(L,key=abs)
print( L1)
print(L.reverse())
N=['Tom','Jerry','Lucy','Jack','Rose']
print(N[::-1])
print(sorted(N,key=len))
#名字倒过来排序(排的时候倒过来排，结果不是这样的)
L2=sorted(N,key=lambda x:x[::-1])
print(L2)

#将字符串从最后面开始往前输出
print(N[::-1])
'''

#递归调用

'''def story():
    print('从前有座山')
    print('山里有座庙')
    print('庙里有个老和尚')
    print('故事的内容是')
    time.sleep(1)
    story()
story()
'''
'''def fx(n):
    print('递归进入第',n,'层')
    if n==4:
        return
    fx(n+1)
    print('递归退出第',n,'层')
fx(1)
'''
#递归一定要控制层数，当符合某一个条件时，停止.基本上所有的递归可以用循环解决
#1+100
'''def getsum(n):
    print('递归进入了第',n,'层')
    if n==1:
        return 1
    sum=n+getsum(n-1)
    return sum
print(getsum(5))

#求阶乘
def getchen(n):
    print('递归进入了第',n,'层')
    if n==1:
        return 1
    return n*getchen(n-1)
print(getchen(3))

#闭包：必须有一个内嵌函数，内嵌函数必须使用到了外部函数的局部变量。外部函数必须返回内部函数的引用
def make_power(y):
    def fx(args):    #定义一个新函数
        return args ** y
    return fx
f=make_power(3)       还在外部函数的情况
print(f(4))  #4的3次方    内部函数
#一般情况下，调用函数结束，在内存中会被释放,闭包不是
#让程序可以访问局部变量
'''
#闭包：内嵌函数可以使用外部函数的局部变量，全局变量也是可以使用的
#nonlocal：将内部函数变量变为外部函数

#计数器的功能
'''total=0
def f1(step):
    global total
    total+=step
f1(1)
#globals是函数的一个属性，属性所属的模块
print(f1.__globals__['total'])
#全局变量多线程不安全
'''

'''def outer(total):
    def inner(step):
        nonlocal total
        # 告诉解释器此处的total变量是外部函数的局部变量
        total+=step
        return total
    return inner
#返回了一个函数，这个函数是一个闭包
f=outer(0)
#closure是闭包的属性，里面存储了闭包函数使用到的外部函数的变量
#内嵌函数引用到外部函数的值（total）
print(f.__closure__)
print(f.__closure__[0].cell_contents)
f(1)
print(f.__closure__[0].cell_contents)
f(1)
print(f.__closure__[0].cell_contents)
f(3)
print(f.__closure__[0].cell_contents)

print('以下是另一个线程')
f1=outer(100)
print(f1.__closure__[0].cell_contents)
f1=outer(10)
print(f1.__closure__[0].cell_contents)
'''

#装饰器
#装饰一个函数，参数传入一个函数，返回一个函数
'''def 装饰器函数名（形参）
  语句块
  return
  '''
#装饰器函数
'''def mydeco(fn):
    def fx():
        print('~~~~~')
        fn()   #相当于被装饰的函数
        print('------')
    return fx

def mydeco2(fn):
    def fx():
        print('你好')
        fn()
    return fx
@mydeco
@mydeco2
def myfun():
    print('这是自定义函数')
myfun()
'''

#模拟银行系统，当存钱或取钱的时候，装饰一段话：欢迎xxx来办理xxx业务
'''def messag_send(fn):
    def fx(name,money):
        print('欢迎',name,'来办理业务')
        fn(name, money)     #被装饰的函数
        print(name,'办理了',money,'元的业务')
    return fx
#权限验证装饰器
def privileged_check(fn):
    def fx(password,num):
        print('正在进行验证')
        if password==123:
            print('成功')
            fn(password,num)
        else:
            print('失败')
    return fx

@messag_send
def save_money(name,money):
    print(name,'存钱',money,'元')
save_money('郭德纲',100)

@privileged_check
def get_money(passwd,num):
    print('取钱成功')
get_money(123,10000)
#执行到被装饰的函数时的形参必须与定义时一致
'''

#函数的__doc__属性：存储了函数的文档字符串
#函数的__name__属性：存储了绑定了函数变量名的字符串
#函数的__globals__属性：存储了函数所在模块的全局变量，字典
#第一个没有被赋值的字符串是文档字符串
'''def f1():
    """这是f1函数的文档字符串"""
    """这是F1函数中的一个普通字符串"""
    print('f1函数')
print(f1.__doc__)
print(f1.__name__)
f2=f1
print(f2.__name__)
print(f1.__globals__) #存储了f1所在的环境的所有的全局变量

#函数的标准写法
[@装饰器1]
[@装饰器2]
[@装饰器3]
......
def 函数名([位置形参],[*元组形参],[命名关键字],[**字典形参]):
    """函数的文档字符串（说明）"""
    函数体
'''

#面试题
'''L=[1,2,3]
#函数的形参缺省值在定义的时候就确定了，而不是每一次调用时才确定
def f(n,lst=[]):
    lst.append(n)
    print(lst)
f(4,L)
f(5,L)
f(100)
f(200)
'''

#模块：包含了一系列的数据，函数，类组成的程序组，通常以.py文件结尾
'''分类：
     内置模块builtins，在解析器自动使用
     标准库模块，安装python解释器后使用
     第三方模块：手动安装，pip包管理工具
     用户自定义模块
     import 模块名 as 别名
     from 模块名 import 属性名
     form 模块名 import *
     from可以将某个模块的某一个属性，或者所有属性引入到当前作用域中，采用这种方式不需要模块.属性的操作
'''

'''import math
import os,sys
import matplotlib as mp
'''
'''print(dir(math)) #返回字符串组成的列表，表示模块下所有变量
print(help(math)) #返回改模块下所有的文档字符串
math.pow(1,2) #两个；x的y次方  
pow() #内置函数，两个三个参数都行
'''
#输入一个正方形的周长，计算正方形的面积
'''a=float(input('请输入周长:'))
c=a/4
print(math.pow(c,2))

r=float(input('请输入圆的半径：'))
print(math.pi*pow(r,2))

n=float(input("请输入正方形的面积："))
b=math.sqrt(n)
print(b*4)

d,e=map(int,input('请输入：').split())
print(d,e)
'''

#from math import pi as p
#from math import *
#print(pi)

#dir函数，返回字符串组成的列表
#dir():参数是一个模块，返回所有的变量组成的列表

#time模块
'''import time
print(dir(time))
'''
#time模块中维护了一个时间元组，9个数组成的
#四位数的年份<100自动补上1900、月1-12、日1-31、时0-23、分0-59、秒0-59、星期0-6、元旦开始日（1-366）、夏令修正时 1 0 -1
'''time.mktime(tuple)  #将时间元组换成秒数
time.localtime(seconds) 将秒数转为时间元组
time.sleep(seconds)  线程休眠
'''

'''import time
#获得用户输入的年月日
year=1999
month=12
day=1
#将三个变量变为元组
birthady=(year,month,day,0,0,0,0,0,0)
#得到这个时间元组维护的秒数（从时间元年到出生的那天经过了多少秒）
birthady_seconds=time.mktime(birthady)
print(birthady_seconds)
#得到当前系统时间维护的秒数
current_seconds=time.time()
print(current_seconds)
print((current_seconds-birthady_seconds)/60/60/24)
'''
'''print(time.localtime())
year=1999
month=12
day=1
birthady=(year,month,day,0,0,0,0,0,0)
birthady_seconds=time.mktime(birthady)
L=time.localtime(birthady_seconds)
print(L)
print(L[6])
'''
#time.time()#获得当前系统的秒数
#做一个电子时钟，在控制台不停的打印当前时间，每一秒打印一次
'''while True:
    L=time.localtime()   #获得当前系统时间组成的时间元组
    #L[3:6] 直接切三个
    print(L[3],':',L[4],':',L[5])
    time.sleep(1)
'''
#做一个闹钟，程序设定一个时间点，控制台不停打印当前时间
#直到到了这个时间点，程序停止
'''L1=[15,59,50]
while True:
    L=time.localtime()
    print(L[3],':',L[4],':',L[5])
    time.sleep(1)
    if L1[0]==L[3] and L1[1]==L[4] and L1[2]==L[5]:
        break
'''
'''hour=int(input("输入闹钟的时："))
min=int(input("输入闹钟的分："))
second=int(input("输入闹钟的秒："))
clock=(hour,min,second)
print(clock)
while True:
    cruuent_tuple=time.localtime()
    current=cruuent_tuple[3:6]
    print(current[0], ':', current[1], ':', current[2])
    time.sleep(1)
    if clock==current:
        break
'''

#sys
# import sys
# print(dir(sys))
# i=[1,2,3,4]
# j=[1,2,3,4]
# d=[x*y for x in i for y in j]
# print(d)

suits = ["♠", "♥", "♦", "♣"]
ranks = ['3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A', '2']
deck = [f"{suit}{rank}" for suit in suits for rank in ranks]
print(deck)